*** Settings ***
Suite Setup       get_config    ${base_url}
Library           RequestsLibrary
Library           json
Library           ExcelLibrary
Library           String
Library           Collections
Resource          用户账号管理.txt
Resource          基础关键字.txt
Library           MyLib.py

*** Variables ***
${username}       admin
${password}       98d2e05d026818c2caaf01d593150207
${base_url}       http://admin.ams.bespinglobal.cn/api

*** Test Cases ***
OPC-验证新增告警推送成功
    [Tags]    notest
    Comment    ok
    ${random_hostId}    Random Int Num    8
    ${data}    get_excel_cell_value    sheet1    OPC-022    请求数据
    &{postdata}    To Json    ${data}
    Set To Dictionary    ${postdata}    hostId=${random_hostId}
    ${api}    get_excel_cell_value    sheet1    OPC-022    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证设置主机维护时间成功
    Comment    ok
    ${random_hostId}    Random Int Num    8
    ${data}    get_excel_cell_value    sheet1    OPC-023    请求数据
    &{postdata}    To Json    ${data}
    Set To Dictionary    ${postdata}    hostId=${random_hostId}
    ${api}    get_excel_cell_value    sheet1    OPC-023    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证编辑主机维护时间成功(1)
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-024    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-024    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证编辑主机维护时间成功(2)
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-025    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-025    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证编辑主机维护时间成功(3)
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-026    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-026    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证编辑主机维护时间成功(4)
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-027    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-027    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证编辑主机维护时间成功(5)
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-028    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-028    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证编辑主机维护时间成功(6)
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-029    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-029    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证设置主机维护时间成功(2)
    Comment    ok
    ${random_hostId}    Random Int Num    8
    ${data}    get_excel_cell_value    sheet1    OPC-030    请求数据
    &{postdata}    To Json    ${data}
    Set To Dictionary    ${postdata}    hostId=${random_hostId}
    ${api}    get_excel_cell_value    sheet1    OPC-030    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证新增告警推送
    Comment    ok
    ${random_hostId}    Random Int Num    8
    ${data}    get_excel_cell_value    sheet1    OPC-031    请求数据
    &{postdata}    To Json    ${data}
    Set To Dictionary    ${postdata}    hostId=${random_hostId}
    ${api}    get_excel_cell_value    sheet1    OPC-031    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证新增告警推送(2)
    Comment    ok
    ${random_hostId}    Random Int Num    8
    ${data}    get_excel_cell_value    sheet1    OPC-032    请求数据
    &{postdata}    To Json    ${data}
    Set To Dictionary    ${postdata}    hostId=${random_hostId}
    ${api}    get_excel_cell_value    sheet1    OPC-032    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证删除告警推送配置
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-033    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-033    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证编辑告警推送配置
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-034    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-034    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-查询列表接口
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-035    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-035    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证根据主机资源查询counter(监控指标)
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-036    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-036    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证根据主机资源查询counter(监控指标)(2)
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-037    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-037    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证业务图表查询接口计算资源详情-监控记录接口
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-038    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-038    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证策略模版列表查询接口
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-039    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-039    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证策略模版列表查询接口(2)
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-040    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-040    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证创建策略模板
    Comment    ok
    ${random_name}    Random Int Num    5
    ${data}    get_excel_cell_value    sheet1    OPC-041    请求数据
    &{postdata}    To Json    ${data}
    Set To Dictionary    ${postdata}    tplName=${random_name}
    ${api}    get_excel_cell_value    sheet1    OPC-041    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True,验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    success    ${out.result.message}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段message为success,验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取完整策略成功
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-014    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-014    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证新增策略(包年包月)成功
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-015    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-015    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证新增策略(按量计费)成功
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-016    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-016    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证单个产品计费
    ${postdata}    get_excel_cell_value    sheet1    OPC-017    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-017    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证批量产品计费
    ${postdata}    get_excel_cell_value    sheet1    OPC-018    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-018    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证批量产品详细计费
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-019    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-019    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证产品扣费
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-020    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-020    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证产品扣费按量计费后付费
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-021    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-021    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证产品扣费按量计费后付费
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-021    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-021    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证新增发票信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-042    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-042    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证修改发票信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-043    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-043    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证删除发票信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-044    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-044    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证查询发票信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-045    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-045    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证设置默认发票信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-046    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-046    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票信息批量删除
    ${postdata}    get_excel_cell_value    sheet1    OPC-047    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-047    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票地址增加
    ${postdata}    get_excel_cell_value    sheet1    OPC-048    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-048    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票地址修改
    ${postdata}    get_excel_cell_value    sheet1    OPC-049    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-049    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票地址删除
    ${postdata}    get_excel_cell_value    sheet1    OPC-050    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-050    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票地址查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-051    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-051    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证设置默认发票地址
    ${postdata}    get_excel_cell_value    sheet1    OPC-052    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-052    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票地址批量删除
    ${postdata}    get_excel_cell_value    sheet1    OPC-053    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-053    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票增加
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-054    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-054    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票变更状态
    [Tags]    notest
    Comment    发票查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-058    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-058    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    发票变更状态
    ${postdata}    get_excel_cell_value    sheet1    OPC-055    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-055    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票退票
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-056    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-056    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票邮寄
    [Tags]    notest
    Comment    查询发票状态为20已出票的发票
    ${postdata}    get_excel_cell_value    sheet1    OPC-060    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-060    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    发票邮寄
    ${postdata}    get_excel_cell_value    sheet1    OPC-057    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-057    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    invoiceId=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证发票查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-058    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-058    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证发票详情查询
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-059    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-059    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

USER-验证消息中心-创建站内信
    ${postdata}    get_excel_cell_value    sheet1    USER-016    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-016    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

USER-验证消息中心 - 获取站内信列表
    ${postdata}    get_excel_cell_value    sheet1    USER-017    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-017    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

USER-验证消息中心 - 站内信推送
    Comment    查询站内信列表
    ${postdata}    get_excel_cell_value    sheet1    USER-017    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-017    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    推送站内信
    ${postdata}    get_excel_cell_value    sheet1    USER-018    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-018    API
    ${id}    Evaluate    str(${id})
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

USER-验证消息中心 - 站内信详情
    Comment    查询站内信列表
    ${postdata}    get_excel_cell_value    sheet1    USER-017    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-017    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    站内信详情
    ${postdata}    get_excel_cell_value    sheet1    USER-019    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-019    API
    ${id}    Evaluate    str(${id})
    ${api}    Replace String    ${api}    {id}    ${id}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证创建银行账户信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-061    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-061    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证查询银行账户信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-062    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-062    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证新增冲值记录
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-063    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-063    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证修改银行信息
    ${postdata}    get_excel_cell_value    sheet1    OPC-064    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-064    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证新增监控推送
    ${postdata}    get_excel_cell_value    sheet1    OPC-065    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-065    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取费用详情
    ${postdata}    get_excel_cell_value    sheet1    OPC-066    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-066    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证生成充值记录
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-067    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-067    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证查询充值记录详情
    ${postdata}    get_excel_cell_value    sheet1    OPC-068    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-068    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证充值记录列表查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-069    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-069    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证充值记录列表条件查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-070    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-070    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

BASIC-验证地区获取省列表
    ${postdata}    get_excel_cell_value    sheet1    BASIC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    BASIC-001    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

BASIC-验证地区获取市列表
    ${postdata}    get_excel_cell_value    sheet1    BASIC-002    请求数据
    ${api}    get_excel_cell_value    sheet1    BASIC-002    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

BASIC-验证地区获取县列表
    ${postdata}    get_excel_cell_value    sheet1    BASIC-003    请求数据
    ${api}    get_excel_cell_value    sheet1    BASIC-003    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证申请工单成功
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取工单类型成功
    Comment    OK
    ${postdata}    get_excel_cell_value    sheet1    OPC-002    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-002    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证获取工单详情信息成功
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].wipId}
    ${api}    get_excel_cell_value    sheet1    OPC-003    API
    ${api}    Replace String    ${api}    {wipId}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证工单查询成功
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证工单反馈分页查询成功
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-005    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-005    API
    log    ${postdata}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证工单处理成功
    Comment    OK
    Comment    创建工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    查询工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].wipId}
    Comment    工单处理成功
    ${postdata}    get_excel_cell_value    sheet1    OPC-006    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-006    API
    ${api}    Replace String    ${api}    {wipId}    ${id}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取待用户反馈的工单个数成功
    Comment    OK
    ${postdata}    get_excel_cell_value    sheet1    OPC-007    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-007    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证工单确认处理完毕成功
    Comment    OK
    Comment    创建工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    查询工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].wipId}
    Comment    工单认领成功
    ${api}    get_excel_cell_value    sheet1    OPC-008    API
    ${api}    Replace String    ${api}    {wipId}    ${id}
    ${resp}    Post Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证认领工单成功
    Comment    OK
    Comment    创建工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    查询工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].wipId}
    Comment    工单认领成功
    Comment    ${postdata}    get_excel_cell_value    sheet1    OPC-009    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-009    API
    ${api}    Replace String    ${api}    {wipId}    ${id}
    ${resp}    Post Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证工单池统计工单成功
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-010    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-010    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证工单概览成功
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-011    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-011    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证管理员端工单池查询成功
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-012    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-012    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证转派工单成功
    Comment    OK
    Comment    创建工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    查询工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].wipId}
    Comment    工单转派成功
    ${api}    get_excel_cell_value    sheet1    OPC-013    API
    ${postdata}    get_excel_cell_value    sheet1    OPC-013    请求数据
    ${api}    Replace String    ${api}    {wipId}    ${id}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

auth-验证管理员登录
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    auth-007    请求数据
    ${api}    get_excel_cell_value    sheet1    auth-007    API
    &{myheader}    Create Dictionary    Content-Type=application/x-www-form-urlencoded    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Contain    bearer    ${out.token_type}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段token_type包含bearer，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Not Be Empty    ${out.access_token}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段access_token不为空，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

auth-验证管理员注销登录
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    auth-008    请求数据
    ${api}    get_excel_cell_value    sheet1    auth-008    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证产品分类-新增分类
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-007    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-007    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证产品分类-修改分类
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    PMS-007    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-007    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${id}    Set Variable    ${out.result}
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-008    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-008    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证产品分类-删除分类
    [Tags]    notest
    Comment    新增分类
    ${postdata}    get_excel_cell_value    sheet1    PMS-007    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-007    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result}
    Comment    删除分类
    ${postdata}    get_excel_cell_value    sheet1    PMS-009    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-009    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证产品分类-绑定code
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-010    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-010    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证产品分类-获取分类下级
    Comment    查询分类列表
    ${postdata}    get_excel_cell_value    sheet1    PMS-012    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-012    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[0].id}
    Comment    查询下级分类
    ${postdata}    get_excel_cell_value    sheet1    PMS-011    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-011    API
    ${api}    Replace String    ${api}    {id}    ${id}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证产品分类-获取产品分类列表
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-012    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-012    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证产品分类-获取两级分类
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-013    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-013    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证产品分类-根据层级查询分类
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-014    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-014    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证新增云商管理
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-015    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-015    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证获取云商管理列表
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证获取云商详情
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[0].id}
    ${postdata}    get_excel_cell_value    sheet1    PMS-017    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-017    API
    ${api}    Replace String    ${api}    {id}    ${id}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证修改云商
    Comment    获取云商管理列表最新一条记录
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[-1].id}
    Comment    修改云商
    ${postdata}    get_excel_cell_value    sheet1    PMS-018    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-018    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证删除云商
    Comment    获取云商管理列表最新一条记录
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[-1].id}
    Comment    删除云商
    ${postdata}    get_excel_cell_value    sheet1    PMS-019    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-019    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-新增云商区域
    Comment    新增云商
    ${postdata}    get_excel_cell_value    sheet1    PMS-015    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-015    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    Comment    查询云商列表
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[-1].id}
    Comment    新增云商区域
    ${postdata}    get_excel_cell_value    sheet1    PMS-020    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-020    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    supplierId=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-查询云商区域regions
    Comment    查询云商列表
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[-1].id}
    Comment    查询云商区域
    ${postdata}    get_excel_cell_value    sheet1    PMS-021    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-021    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-查询云商可用区zones
    Comment    查询云商列表
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[-1].id}
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-022    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-022    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-修改云商区域
    [Tags]    notest
    Comment    查询云商列表
    ${postdata}    get_excel_cell_value    sheet1    PMS-016    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-016    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result[-1].id}
    Comment    修改云端区域
    ${postdata}    get_excel_cell_value    sheet1    PMS-023    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-023    API
    ${api}    Replace String    ${api}    {id}    ${id}
    Comment    &{data}    To Json    ${postdata}
    Comment    Set To Dictionary    ${data}    supplierId=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-删除云商区域
    [Tags]    notest
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-024    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-024    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-修改云商区域排序
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    PMS-025    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-025    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证导出记录文件下载
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-113    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-113    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    log    请求API：${api}
    log    接口返回值：${resp}
    Comment    Should Be Equal As Strings    <Response [200]>    ${resp}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    <Response [200]>    ${resp}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回状态码为200，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-充值记录导出
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-114    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-114    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    log    请求API：${api}
    log    接口返回值：${resp}
    Comment    Should Be Equal As Strings    <Response [200]>    ${resp}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    <Response [200]>    ${resp}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回状态码为200，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证接受转工单
    Comment    创建工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    查询工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].wipId}
    Comment    Comment    工单转派成功
    Comment    ${api}    get_excel_cell_value    sheet1    OPC-013    API
    Comment    ${postdata}    get_excel_cell_value    sheet1    OPC-013    请求数据
    Comment    ${api}    Replace String    ${api}    {wipId}    ${id}
    Comment    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    Comment    &{out}    To Json    ${resp.text}
    Comment    Should Be Equal As Strings    True    ${out.success}
    Comment    接受转工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-115    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-115    API
    ${api}    Replace String    ${api}    {wipld}    ${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证拒绝转工单
    Comment    创建工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-001    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    查询工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-004    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-004    API
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].wipId}
    Comment    工单转派成功
    ${api}    get_excel_cell_value    sheet1    OPC-013    API
    ${postdata}    get_excel_cell_value    sheet1    OPC-013    请求数据
    ${api}    Replace String    ${api}    {wipId}    ${id}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Should Be Equal As Strings    True    ${out.success}
    Comment    拒绝转工单
    ${postdata}    get_excel_cell_value    sheet1    OPC-116    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-116    API
    ${api}    Replace String    ${api}    {wipld}    ${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证管理员端个人查询
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-117    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-117    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证统计工单
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-118    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-118    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取产品类型
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-119    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-119    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证发票订单查询
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-120    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-120    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证发票状态查询
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-121    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-121    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证预览图片（下载图片）
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-122    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-122    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    log    请求API：${api}
    log    接口返回值：${resp}
    Comment    Should Be Equal As Strings    <Response [200]>    ${resp}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    <Response [200]>    ${resp}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回状态码200，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证获取充值模块默认的银行账户信息
    Comment    ok
    ${postdata}    get_excel_cell_value    sheet1    OPC-123    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-123    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券批次新增
    ${postdata}    get_excel_cell_value    sheet1    OPC-124    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-124    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券批次修改
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    批次修改
    ${postdata}    get_excel_cell_value    sheet1    OPC-125    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-125    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券批次删除
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    批次删除
    ${postdata}    get_excel_cell_value    sheet1    OPC-126    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-126    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证代金券批次激活
    Comment    新增
    ${postdata}    get_excel_cell_value    sheet1    OPC-124    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-124    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    激活
    ${postdata}    get_excel_cell_value    sheet1    OPC-128    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-128    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券批次批量删除
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-129    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-129    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Should Be Equal As Strings    True    ${out.success}
    Comment    新增
    ${postdata}    get_excel_cell_value    sheet1    OPC-124    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-124    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    新增
    ${postdata}    get_excel_cell_value    sheet1    OPC-124    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-124    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    ${id2}    Set Variable    ${out.result.data[1].id}
    Comment    批量删除
    ${postdata}    get_excel_cell_value    sheet1    OPC-129    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-129    API
    ${api}    Replace String    ${api}    {id},{id}    ${id},${id2}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券查询
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    代金券查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-130    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-130    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    couponStockId=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券批量删除
    Comment    新增
    ${postdata}    get_excel_cell_value    sheet1    OPC-124    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-124    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    激活
    ${postdata}    get_excel_cell_value    sheet1    OPC-128    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-128    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    代金券查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-130    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-130    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    couponStockId=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    ${id2}    Set Variable    ${out.result.data[1].id}
    Comment    代金券批量删除
    ${postdata}    get_excel_cell_value    sheet1    OPC-131    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-131    API
    ${api}    Replace String    ${api}    {id},{id}    ${id},${id2}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证代金券消费
    Comment    新增
    ${postdata}    get_excel_cell_value    sheet1    OPC-124    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-124    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    激活
    ${postdata}    get_excel_cell_value    sheet1    OPC-128    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-128    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    Comment    批次查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-127    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-127    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    代金券查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-130    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-130    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    couponStockId=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    消费
    ${postdata}    get_excel_cell_value    sheet1    OPC-132    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-132    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    couponId=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证添加新闻动态
    ${postdata}    get_excel_cell_value    sheet1    OPC-071    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-071    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取新闻动态
    Comment    获取新闻动态列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-073    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-073    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    获取新闻动态
    ${postdata}    get_excel_cell_value    sheet1    OPC-072    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-072    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取新闻动态列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-073    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-073    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证修改新闻动态
    Comment    获取新闻动态列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-073    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-073    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    修改新闻动态
    ${postdata}    get_excel_cell_value    sheet1    OPC-074    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-074    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证获取新闻子动态列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-075    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-075    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证新闻动态-上下架
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-076    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-076    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理-增加首页导航
    ${postdata}    get_excel_cell_value    sheet1    OPC-085    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-085    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 修改首页导航
    Comment    查询导航列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-087    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-087    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    @{list}    Set Variable    ${out.result.data}
    : FOR    ${var}    IN    @{list}
    \    Exit For Loop If    '${var.title}'=='自动化测试'
    ${id}    Set Variable    ${var.id}
    Comment    修改首页导航
    ${postdata}    get_excel_cell_value    sheet1    OPC-086    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-086    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 删除首页导航
    Comment    查询导航列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-087    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-087    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    @{list}    Set Variable    ${out.result.data}
    : FOR    ${var}    IN    @{list}
    \    Exit For Loop If    '${var.title}'=='帮助'
    ${id}    Set Variable    ${var.id}
    Comment    修改首页导航
    ${postdata}    get_excel_cell_value    sheet1    OPC-163    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-163    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 查询首页导航列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-087    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-087    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 查询导航启用列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-088    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-088    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 查询首页页脚列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-089    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-089    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 增加首页页脚
    ${postdata}    get_excel_cell_value    sheet1    OPC-090    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-090    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 首页页脚修改
    ${postdata}    get_excel_cell_value    sheet1    OPC-091    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-091    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 查询首页页脚站点信息列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-092    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-092    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 首页页脚站点信息修改
    ${postdata}    get_excel_cell_value    sheet1    OPC-093    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-093    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 首页模块列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-094    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-094    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 首页模块显示
    ${postdata}    get_excel_cell_value    sheet1    OPC-095    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-095    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 字典列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-096    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-096    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 批量保存字典
    ${postdata}    get_excel_cell_value    sheet1    OPC-097    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-097    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 字典获取
    ${postdata}    get_excel_cell_value    sheet1    OPC-098    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-098    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 创建广告
    ${postdata}    get_excel_cell_value    sheet1    OPC-099    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-099    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 获取广告列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-100    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-100    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 获取广告详情
    ${postdata}    get_excel_cell_value    sheet1    OPC-100    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-100    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${id}    Set Variable    ${out.result.data[0].id}
    Comment    获取广告详情
    ${postdata}    get_excel_cell_value    sheet1    OPC-101    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-101    API
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 广告修改
    ${postdata}    get_excel_cell_value    sheet1    OPC-100    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-100    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    @{list}    Set Variable    ${out.result.data}
    : FOR    ${var}    IN    @{list}
    \    Exit For Loop If    '${var.name}'=='autotest优惠活动'
    ${id}    Set Variable    ${var.id}
    ${postdata}    get_excel_cell_value    sheet1    OPC-102    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-102    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 广告修改权重
    ${postdata}    get_excel_cell_value    sheet1    OPC-100    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-100    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    ${id}    Set Variable    ${out.result.data[0].id}
    ${postdata}    get_excel_cell_value    sheet1    OPC-103    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-103    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 获取广告展示列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-104    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-104    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 获取广告配置列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-105    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-105    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 首页页脚批量修改
    ${postdata}    get_excel_cell_value    sheet1    OPC-106    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-106    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 广告配置详情
    ${postdata}    get_excel_cell_value    sheet1    OPC-107    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-107    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 增加协议
    ${code}    Random Num    10
    ${postdata}    get_excel_cell_value    sheet1    OPC-108    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-108    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    code=${code}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 修改协议
    Comment    查询协议
    ${postdata}    get_excel_cell_value    sheet1    OPC-112    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-112    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    @{list}    Set Variable    ${out.result.data}
    : FOR    ${var}    IN    @{list}
    \    Exit For Loop If    '${var.name}'=='autotest协议'
    ${id}    Set Variable    ${var.id}
    ${code}    Set Variable    ${var.code}
    Comment    修改协议
    ${postdata}    get_excel_cell_value    sheet1    OPC-109    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-109    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    Set To Dictionary    ${data}    code=${code}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证内容管理 - 协议详情
    ${postdata}    get_excel_cell_value    sheet1    OPC-110    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-110    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 协议详情ByCode
    ${postdata}    get_excel_cell_value    sheet1    OPC-111    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-111    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证内容管理 - 协议列表
    ${postdata}    get_excel_cell_value    sheet1    OPC-112    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-112    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证查询续费产品列表
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    PMS-001    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-001    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证保存续费配置
    ${postdata}    get_excel_cell_value    sheet1    PMS-002    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-002    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

USER-验证消息中心-发送邮件
    ${postdata}    get_excel_cell_value    sheet1    USER-002    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-002    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

USER-验证消息中心-增加消息分类
    ${postdata}    get_excel_cell_value    sheet1    USER-003    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-003    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

USER-验证消息中心-修改消息分类
    [Tags]
    Comment    查询消息分类
    ${postdata}    get_excel_cell_value    sheet1    USER-006    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-006    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    @{list}    Set Variable    ${out.result.data}
    : FOR    ${var}    IN    @{list}
    \    Exit For Loop If    '${var.name}'=='会员消息'
    ${id}    Set Variable    ${var.id}
    Comment    修改消息分类
    ${postdata}    get_excel_cell_value    sheet1    USER-004    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-004    API
    log    ${postdata}
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    id=${id}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Put Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${data}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

USER-验证消息中心-删除消息分类
    [Tags]
    Comment    查询消息分类
    ${postdata}    get_excel_cell_value    sheet1    USER-006    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-006    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    @{list}    Set Variable    ${out.result.data}
    : FOR    ${var}    IN    @{list}
    \    Exit For Loop If    '${var.name}'=='会员消息'
    ${id}    Set Variable    ${var.id}
    ${postdata}    get_excel_cell_value    sheet1    USER-005    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-005    API
    ${id}    evaluate    str(${id})
    ${api}    Replace String    ${api}    {id}    ${id}
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Delete Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

USER-验证消息中心-获取分类列表
    ${postdata}    get_excel_cell_value    sheet1    USER-006    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-006    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

USER-验证消息中心-获取用户消息列表
    ${postdata}    get_excel_cell_value    sheet1    USER-007    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-007    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

USER-验证消息中心-消息统计
    ${postdata}    get_excel_cell_value    sheet1    USER-015    请求数据
    ${api}    get_excel_cell_value    sheet1    USER-015    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证账单总览成功
    ${postdata}    get_excel_cell_value    sheet1    OPC-133    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-133    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证销售账单总览-手机端
    [Tags]
    ${postdata}    get_excel_cell_value    sheet1    OPC-134    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-134    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证销售账单总览
    ${postdata}    get_excel_cell_value    sheet1    OPC-135    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-135    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证账单查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-136    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-136    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证增加账单和明细
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-137    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-137    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证账单明细查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-138    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-138    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证账单导出
    ${postdata}    get_excel_cell_value    sheet1    OPC-139    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-139    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    Comment    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${resp }
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    <Response [200]>    ${resp}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${resp } \n请求API：${api}

OPC-验证账单明细导出
    ${postdata}    get_excel_cell_value    sheet1    OPC-140    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-140    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    Comment    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${resp}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    <Response [200]>    ${resp}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${resp} \n请求API：${api}

OPC-验证导出日志增加
    ${postdata}    get_excel_cell_value    sheet1    OPC-141    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-141    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证导出日志查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-142    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-142    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证导出文件下载
    ${postdata}    get_excel_cell_value    sheet1    OPC-143    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-143    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    Comment    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${resp}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    <Response [200]>    ${resp}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${resp} \n请求API：${api}

OPC-验证广告账单导出
    ${postdata}    get_excel_cell_value    sheet1    OPC-144    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-144    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    log    请求API：${api}
    log    接口返回值：${resp}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    <Response [200]>    ${resp}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${resp} \n请求API：${api}

OPC-验证成本账单-账单查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-145    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-145    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证成本账单-账单明细查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-146    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-146    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证成本账单总览
    ${postdata}    get_excel_cell_value    sheet1    OPC-147    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-147    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证账单总览
    ${postdata}    get_excel_cell_value    sheet1    OPC-148    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-148    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证获取账单总览
    ${postdata}    get_excel_cell_value    sheet1    OPC-149    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-149    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证获取账单
    ${postdata}    get_excel_cell_value    sheet1    OPC-150    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-150    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证获取账单明细
    ${postdata}    get_excel_cell_value    sheet1    OPC-151    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-151    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证获取账单查询条件
    ${postdata}    get_excel_cell_value    sheet1    OPC-152    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-152    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证试用账单查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-153    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-153    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证试用账单明细查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-154    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-154    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证产品退费
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-155    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-155    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证产品试用扣费
    ${postdata}    get_excel_cell_value    sheet1    OPC-156    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-156    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证广告扣费
    ${postdata}    get_excel_cell_value    sheet1    OPC-157    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-157    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证广告修改扣费
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-158    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-158    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证广告账单查询
    ${postdata}    get_excel_cell_value    sheet1    OPC-159    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-159    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证修改会员等级
    ${postdata}    get_excel_cell_value    sheet1    OPC-160    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-160    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

OPC-验证查询会员等级
    ${postdata}    get_excel_cell_value    sheet1    OPC-161    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-161    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

OPC-验证修改会员等级2
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    OPC-162    请求数据
    ${api}    get_excel_cell_value    sheet1    OPC-162    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证修改云市场运营定制指标
    [Tags]    notest
    ${postdata}    get_excel_cell_value    sheet1    PMS-043    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-043    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证查询产品的运营指标接口信息
    ${postdata}    get_excel_cell_value    sheet1    PMS-044    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-044    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证产品点击次数查询
    ${postdata}    get_excel_cell_value    sheet1    PMS-045    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-045    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证用户数据总览
    ${postdata}    get_excel_cell_value    sheet1    PMS-046    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-046    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

PMS-验证查询投放中的广告列表
    ${postdata}    get_excel_cell_value    sheet1    PMS-047    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-047    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证查询历史投放记录
    ${postdata}    get_excel_cell_value    sheet1    PMS-048    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-048    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

PMS-验证添加手动排名
    ${random_string}    Random Num    10
    ${postdata}    get_excel_cell_value    sheet1    PMS-049    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-049    API
    &{data}    To Json    ${postdata}
    Set To Dictionary    ${data}    typeKeyWord=${random_string}
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${data}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${data}

PMS-验证修改排名规则设置
    ${postdata}    get_excel_cell_value    sheet1    PMS-050    请求数据
    ${api}    get_excel_cell_value    sheet1    PMS-050    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

ISV-验证添加服务商等级
    ${postdata}    get_excel_cell_value    sheet1    ISV-001    请求数据
    ${api}    get_excel_cell_value    sheet1    ISV-001    API
    &{myheader}    Create Dictionary    Content-Type=application/json    authorization=${token}
    ${resp}    Post Request    ${session}    ${api}    data=${postdata}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求参数：${postdata}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api} \n请求参数：${postdata}

ISV-验证等级分页查询
    ${postdata}    get_excel_cell_value    sheet1    ISV-002    请求数据
    ${api}    get_excel_cell_value    sheet1    ISV-002    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}

ISV-验证查询等级分页日志
    ${postdata}    get_excel_cell_value    sheet1    ISV-003    请求数据
    ${api}    get_excel_cell_value    sheet1    ISV-003    API
    &{myheader}    Create Dictionary    authorization=${token}
    ${resp}    Get Request    ${session}    ${api}    headers=&{myheader}
    &{out}    To Json    ${resp.text}
    log    请求API：${api}
    log    接口返回值：${out}
    ${result}    ${returnvalue}    Run Keyword And Ignore Error    Should Be Equal As Strings    True    ${out.success}
    Run Keyword If    '${result}'=='FAIL'    Fail    验证返回值字段success为True，验证失败，错误信息： ${returnvalue} \n接口返回值：${out} \n请求API：${api}
